home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWButtonCell.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  15.3 KB  |  555 lines
  1.  
  2. #import "WWButton.h"
  3. #import "WWButtonCell.h"
  4. #import "WWTCLInterp.h"
  5.  
  6. #import "avoidStupidWarnings.h"
  7.  
  8. @implementation WWButtonCell
  9.  
  10.  
  11. + initialize { [WWButtonCell setVersion:3]; return self; }
  12. ////////////////////////////////////////////////////////
  13. //
  14. - init
  15. {
  16.   [super init];
  17.   controlStringSize = 32;
  18.   controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  19.   sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  20.   tclExpressionSize = 32;
  21.   tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  22.   tclVarSize = 32;
  23.   tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  24.   tclCommandSize = 32;
  25.   tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  26.   interp = nil;
  27.   tclCommandDirty = YES;
  28.  
  29.   return self;
  30. }
  31. //
  32. - awake
  33. {
  34.   [super awake];
  35.   tclCommandDirty = YES;
  36.   return self;
  37. }
  38.  
  39. - free
  40. {
  41.   if (controlString) { NXZoneFree([self zone], controlString); }
  42.   if (sprintfControlString) { NXZoneFree([self zone], sprintfControlString); }
  43.   if (tclExpression) { NXZoneFree([self zone], tclExpression); }
  44.   if (tclVar) { NXZoneFree([self zone], tclVar); }
  45.   if (tclCommand) { NXZoneFree([self zone], tclCommand); }
  46.   return [super free];
  47. }
  48.  
  49. - reinitializeControlStringAndTclVarFromZone:(NXZone *)zone
  50. {
  51.   controlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  52.   sprintfControlString = (char *)NXZoneCalloc(zone, controlStringSize, sizeof(char));
  53.   tclExpression = (char *)NXZoneCalloc(zone, tclExpressionSize, sizeof(char));
  54.   tclVar = (char *)NXZoneCalloc(zone, tclVarSize, sizeof(char));
  55.   tclCommand = (char *)NXZoneCalloc(zone, tclCommandSize, sizeof(char));
  56.   return self;
  57. }
  58.  
  59. - copyFromZone:(NXZone *)zone
  60. {
  61.   id newCopy = [super copyFromZone:zone];
  62.  
  63.  
  64.   [newCopy reinitializeControlStringAndTclVarFromZone:zone];
  65.   [newCopy setControlString:controlString];
  66.   [newCopy setTclExpression:tclExpression];
  67.   [newCopy setTclVar:tclVar];
  68.   [newCopy setTclCommand:tclCommand];
  69.  
  70.   return newCopy;
  71. }
  72.  
  73. - setInterp:newInterp { interp = newInterp; return self; }
  74. - interp { return interp; }
  75.  
  76. - resizeTclCommandForArgVector:(char *)argOrderVector
  77. {
  78.   BOOL    done = NO;
  79.   
  80.  
  81.   if (!done && !strcmp("d", argOrderVector))
  82.   {  while (tclCommandSize < (controlStringSize + 32))
  83.      {  if (!tclCommandSize)
  84.     {  tclCommandSize = 32;
  85.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  86.         }
  87.         else
  88.         {  tclCommandSize *= 2;
  89.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  90.         }
  91.      }
  92.      done = YES;
  93.   }
  94.   if (!done && !strcmp("T", argOrderVector))
  95.   {  while (tclCommandSize < (controlStringSize + 32))
  96.      {  if (!tclCommandSize)
  97.     {  tclCommandSize = 32;
  98.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  99.         }
  100.         else
  101.         {  tclCommandSize *= 2;
  102.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  103.         }
  104.      }
  105.      done = YES;
  106.   }
  107.   if (!done && !strcmp("f", argOrderVector))
  108.   {  while (tclCommandSize < (controlStringSize + 32) )
  109.      {  if (!tclCommandSize)
  110.     {  tclCommandSize = 32;
  111.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  112.         }
  113.         else
  114.         {  tclCommandSize *= 2;
  115.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  116.         }
  117.      }
  118.      done = YES;
  119.   }
  120.  
  121.   if (!done && !strcmp("s", argOrderVector))
  122.   {  const char  *str = [self stringValue]; 
  123.      int   strLen = strlen(str);
  124.  
  125.      while (tclCommandSize < (controlStringSize + strLen))
  126.      {  if (!tclCommandSize)
  127.     {  tclCommandSize = 32;
  128.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  129.         }
  130.         else
  131.         {  tclCommandSize *= 2;
  132.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  133.         }
  134.      }
  135.      done = YES;
  136.   }
  137.   // those were the easy ones; now for the permutations...
  138.  
  139.   return self;
  140. }
  141.  
  142.  
  143. - updateTclCommand
  144. {
  145.   char    *controlStringPtr, *sprintfControlStringPtr;
  146.   BOOL    done;
  147.   int     argOrderSize = 32;
  148.   char    *argOrderVector = (char *)NXZoneCalloc([self zone], argOrderSize, sizeof(char));
  149.   int     argOrderOffset = 0;
  150.  
  151.  
  152.   if (!controlString)
  153.   {  return nil;
  154.   }
  155.  
  156.   // we want to grovel over the controlString, 
  157.   // for right now, we really only tend to have the following patterns 
  158.   // in the controlString: 1 %f, 1 %d, 1 %s, %R, %G, %B, 1 %T
  159.   controlStringPtr = controlString;
  160.   sprintfControlStringPtr = sprintfControlString;
  161.   strcpy(sprintfControlString, controlString);
  162.   while (*controlStringPtr)
  163.   {  if (*controlStringPtr == '%')
  164.      {  sprintfControlStringPtr++;  controlStringPtr++;
  165.         if (*controlStringPtr)
  166.         {  switch (*controlStringPtr)
  167.            {  case 'd':    while (argOrderOffset >= argOrderSize)
  168.                         {  argOrderSize *= 2;
  169.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  170.                         }
  171.                         argOrderVector[argOrderOffset++] = 'd';
  172.                         sprintfControlStringPtr++; controlStringPtr++;
  173.             break;
  174.               case 'T':    while (argOrderOffset >= argOrderSize)
  175.                         {  argOrderSize *= 2;
  176.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  177.                         }
  178.                         argOrderVector[argOrderOffset++] = 'T';
  179.                         *sprintfControlStringPtr++ = 'd'; controlStringPtr++;
  180.             break;
  181.               case 'f':    while (argOrderOffset >= argOrderSize)
  182.                         {  argOrderSize *= 2;
  183.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  184.                         }
  185.                         argOrderVector[argOrderOffset++] = 'f';
  186.                         sprintfControlStringPtr++; controlStringPtr++;
  187.             break;
  188.               case 's':    while (argOrderOffset >= argOrderSize)
  189.                         {  argOrderSize *= 2;
  190.                            argOrderVector = (char *)NXZoneRealloc([self zone], argOrderVector, argOrderSize);
  191.                         }
  192.                         argOrderVector[argOrderOffset++] = 's';
  193.                         sprintfControlStringPtr++; controlStringPtr++;
  194.             break;
  195.               case '%':    sprintfControlStringPtr++; controlStringPtr++;
  196.                         break;
  197.                default:    NXLogError("WWSliderCell: unknown specifier <%c> in controlString.\n", *controlStringPtr);
  198.                         sprintfControlStringPtr++; controlStringPtr++;
  199.             break;
  200.            }
  201.        }
  202.      }
  203.      else
  204.      {  sprintfControlStringPtr++;  controlStringPtr++;
  205.      }
  206.   }
  207.   argOrderVector[argOrderOffset] = 0;
  208.  
  209.   done = NO;
  210.  
  211.   if (!done && !strcmp("d", argOrderVector))
  212.   {  [self resizeTclCommandForArgVector:argOrderVector];
  213.      sprintf(tclCommand, sprintfControlString, [self intValue]);
  214.      done = YES;
  215.   }
  216.   if (!done && !strcmp("f", argOrderVector))
  217.   {  [self resizeTclCommandForArgVector:argOrderVector];
  218.      sprintf(tclCommand, sprintfControlString, [self floatValue]);
  219.      done = YES;
  220.   }
  221.   if (!done && !strcmp("s", argOrderVector))
  222.   {  [self resizeTclCommandForArgVector:argOrderVector];
  223.      sprintf(tclCommand, sprintfControlString, [self stringValue]);
  224.      done = YES;
  225.   }
  226.   if (!done && !strcmp("T", argOrderVector))
  227.   {  [self resizeTclCommandForArgVector:argOrderVector];
  228.      sprintf(tclCommand, sprintfControlString, [self tag]);
  229.      done = YES;
  230.   }
  231.   if (!done && !strcmp("dT", argOrderVector))
  232.   {  [self resizeTclCommandForArgVector:argOrderVector];
  233.      sprintf(tclCommand, sprintfControlString, [self intValue], [self tag]);
  234.      done = YES;
  235.   }
  236.   if (!done && !strcmp("fT", argOrderVector))
  237.   {  [self resizeTclCommandForArgVector:argOrderVector];
  238.      sprintf(tclCommand, sprintfControlString, [self floatValue], [self tag]);
  239.      done = YES;
  240.   }
  241.   if (!done && !strcmp("sT", argOrderVector))
  242.   {  [self resizeTclCommandForArgVector:argOrderVector];
  243.      sprintf(tclCommand, sprintfControlString, [self stringValue], [self tag]);
  244.      done = YES;
  245.   }
  246.   if (!done && !strcmp("Td", argOrderVector))
  247.   {  [self resizeTclCommandForArgVector:argOrderVector];
  248.      sprintf(tclCommand, sprintfControlString, [self tag], [self intValue]);
  249.      done = YES;
  250.   }
  251.   if (!done && !strcmp("Tf", argOrderVector))
  252.   {  [self resizeTclCommandForArgVector:argOrderVector];
  253.      sprintf(tclCommand, sprintfControlString, [self tag], [self floatValue]);
  254.      done = YES;
  255.   }
  256.   if (!done && !strcmp("Ts", argOrderVector))
  257.   {  [self resizeTclCommandForArgVector:argOrderVector];
  258.      sprintf(tclCommand, sprintfControlString, [self tag], [self stringValue]);
  259.      done = YES;
  260.   }
  261.  
  262.   if (!done)
  263.   {  while (tclCommandSize < controlStringSize)
  264.      {  if (!tclCommandSize)
  265.     {  tclCommandSize = 32;
  266.            tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  267.         }
  268.         else
  269.         {  tclCommandSize *= 2;
  270.            tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  271.         }
  272.      }
  273.      strcpy(tclCommand, controlString);
  274.   }
  275.   tclCommandDirty = NO;
  276.  
  277.   NXZoneFree([self zone], argOrderVector);
  278.  
  279.   return self;
  280. }
  281.  
  282.  
  283. - evaluateSelf
  284. {
  285.    int   ret;
  286.    char  *newStringValue;
  287.    id    retID;
  288.  
  289.  
  290.   newStringValue = [interp globalEval:tclExpression :&ret];
  291.   if ((ret == TCL_OK) || (ret == TCL_RETURN))
  292.   {  [self setStringValue:newStringValue];
  293.      retID = self;
  294.   }
  295.   else
  296.   {  NXLogError("WWSliderCell: error <%s> evaluating tcl expression <%s>\n", 
  297.         newStringValue, tclExpression);
  298.      if (newStringValue) { free(newStringValue); }
  299.      retID = nil;
  300.   }
  301.   return retID;
  302. }
  303.  
  304. - updateInterp
  305. {
  306.   if ([interp eval:[self tclCommand]])
  307.   {  return self;
  308.   }
  309.   return nil;
  310. }
  311.  
  312. - setIntValue:(int)val
  313. {
  314.   [super setIntValue:val];
  315.   tclCommandDirty = YES;
  316.   return self;
  317. }
  318.  
  319. - setFloatValue:(float)val
  320. {
  321.   [super setFloatValue:val];
  322.   tclCommandDirty = YES;
  323.   return self;
  324. }
  325.  
  326. - setDoubleValue:(double)val
  327. {
  328.   [super setDoubleValue:val];
  329.   tclCommandDirty = YES;
  330.   return self;
  331. }
  332.  
  333. - setStringValue:(const char *)str
  334. {
  335.   [super setStringValue:str];
  336.   if (str && *str) 
  337.   {  [self setIntValue:atoi(str)];
  338.   }
  339.   else
  340.   {  [self setIntValue:0];
  341.   }
  342.   return self;
  343. }
  344.  
  345.  
  346. - setControlString:(const char *)str 
  347. { 
  348.   int   cnt;
  349.  
  350.  
  351.   if (!str) { return self; }
  352.   if (controlStringSize <= 0) 
  353.   {  controlStringSize = 32; 
  354.      controlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  355.   }
  356.   cnt = strlen(str);
  357.   while (cnt >= controlStringSize)
  358.   {  controlStringSize *= 2;
  359.      controlString = (char *)NXZoneRealloc([self zone], controlString, controlStringSize);
  360.   }
  361.   if (sprintfControlString)
  362.   {  sprintfControlString = (char *)NXZoneRealloc([self zone], sprintfControlString, controlStringSize);
  363.   }
  364.   else
  365.   {  sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  366.   }
  367.   strcpy(controlString, str); 
  368.   tclCommandDirty = YES;
  369.   return self; 
  370. }
  371. //
  372. - (const char *)controlString { return controlString; }
  373.  
  374. - setTclExpression:(const char *)str 
  375. { 
  376.   int   cnt;
  377.  
  378.  
  379.   if (!str) { return self; }
  380.   if (tclExpressionSize <= 0) 
  381.   {  tclExpressionSize = 32; 
  382.      tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  383.   }
  384.   cnt = strlen(str);
  385.   while (cnt >= tclExpressionSize)
  386.   {  tclExpressionSize *= 2;
  387.      tclExpression = (char *)NXZoneRealloc([self zone], tclExpression, tclExpressionSize);
  388.   }
  389.   strcpy(tclExpression, str); 
  390.   return self; 
  391. }
  392. //
  393. - (const char *)tclExpression { return tclExpression; }
  394.  
  395. - setTclVar:(const char *)str 
  396. { 
  397.   int   cnt;
  398.  
  399.  
  400.   if (!str) { return self; }
  401.   if (tclVarSize <= 0) 
  402.   {  tclVarSize = 32; 
  403.      tclVar = (char *)NXZoneCalloc([self zone], tclVarSize, sizeof(char));
  404.   }
  405.   cnt = strlen(str);
  406.   while (cnt >= tclVarSize)
  407.   {  tclVarSize *= 2;
  408.      tclVar = (char *)NXZoneRealloc([self zone], tclVar, tclVarSize);
  409.   }
  410.   strcpy(tclVar, str); 
  411.   return self; 
  412. }
  413. //
  414. - (const char *)tclVar { return tclVar; }
  415.  
  416. - setTclCommand:(const char *)str 
  417. { 
  418.   int   cnt;
  419.  
  420.  
  421.   if (!str) { return self; }
  422.   if (tclCommandSize <= 0) 
  423.   {  tclCommandSize = 32; 
  424.      tclCommand = (char *)NXZoneCalloc([self zone], tclCommandSize, sizeof(char));
  425.   }
  426.   cnt = strlen(str);
  427.   while (cnt >= tclCommandSize)
  428.   {  tclCommandSize *= 2;
  429.      tclCommand = (char *)NXZoneRealloc([self zone], tclCommand, tclCommandSize);
  430.   }
  431.   strcpy(tclCommand, str); 
  432.   return self; 
  433. }
  434. //
  435. - (const char *)tclCommand 
  436. { 
  437.   if (tclCommandDirty)
  438.   {  [self updateTclCommand];
  439.   }
  440.   return tclCommand; 
  441. }
  442.  
  443. - write:(NXTypedStream *)stream 
  444. {
  445.    [super write:stream];
  446.    NXWriteType(stream, "*", &controlString);
  447.    NXWriteType(stream, "*", &tclVar);
  448.    NXWriteType(stream, "*", &tclExpression);
  449.    NXWriteType(stream, "*", &tclCommand);
  450.    NXWriteObjectReference(stream, interp);
  451.    return self;
  452. }
  453. //
  454. - read:(NXTypedStream *)stream 
  455. {
  456.    int version;
  457.  
  458.    [super read:stream];
  459.  
  460.    version = NXTypedStreamClassVersion(stream, "WWButtonCell");
  461.    if (version == 1)
  462.    {  NXReadType(stream, "*", &controlString);
  463.       if (controlString) 
  464.       {  controlStringSize = strlen(controlString) + 1;
  465.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  466.       }
  467.       else
  468.       {  controlStringSize = 0;
  469.          sprintfControlString = NULL;
  470.       }
  471.       NXReadType(stream, "*", &tclVar);
  472.       if (tclVar) 
  473.       {  tclVarSize = strlen(tclVar) + 1;
  474.       }
  475.       else
  476.       { tclVarSize = 0;
  477.       }
  478.       tclExpressionSize = 32;
  479.       tclExpression = (char *)NXZoneCalloc([self zone], tclExpressionSize, sizeof(char));
  480.    }
  481.    if (version == 2)
  482.    {  NXReadType(stream, "*", &controlString);
  483.       if (controlString) 
  484.       {  controlStringSize = strlen(controlString) + 1;
  485.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  486.       }
  487.       else
  488.       {  controlStringSize = 0;
  489.          sprintfControlString = NULL;
  490.       }
  491.       NXReadType(stream, "*", &tclVar);
  492.       if (tclVar) 
  493.       {  tclVarSize = strlen(tclVar) + 1;
  494.       }
  495.       else
  496.       { tclVarSize = 0;
  497.       }
  498.       NXReadType(stream, "*", &tclExpression);
  499.       if (tclExpression) 
  500.       {  tclExpressionSize = strlen(tclExpression) + 1;
  501.       }
  502.       else
  503.       {  tclExpressionSize = 0;
  504.       }
  505.    }
  506.    if (version == 3)
  507.    {  NXReadType(stream, "*", &controlString);
  508.       if (controlString) 
  509.       {  controlStringSize = strlen(controlString) + 1;
  510.          sprintfControlString = (char *)NXZoneCalloc([self zone], controlStringSize, sizeof(char));
  511.       }
  512.       else
  513.       {  controlStringSize = 0;
  514.          sprintfControlString = NULL;
  515.       }
  516.       NXReadType(stream, "*", &tclVar);
  517.       if (tclVar) 
  518.       {  tclVarSize = strlen(tclVar) + 1;
  519.       }
  520.       else
  521.       { tclVarSize = 0;
  522.       }
  523.       NXReadType(stream, "*", &tclExpression);
  524.       if (tclExpression) 
  525.       {  tclExpressionSize = strlen(tclExpression) + 1;
  526.       }
  527.       else
  528.       {  tclExpressionSize = 0;
  529.       }
  530.       NXReadType(stream, "*", &tclCommand);
  531.       if (tclCommand) 
  532.       {  tclCommandSize = strlen(tclCommand) + 1;
  533.       }
  534.       else
  535.       {  tclCommandSize = 0;
  536.       }
  537.       interp = NXReadObject(stream);
  538.    }
  539.    return self;
  540. }
  541.  
  542. // IB stuff
  543. - (const char *)getInspectorClassName 
  544. {  
  545.    NXEvent  *event = [NXApp currentEvent];
  546.  
  547.    if (event->flags & NX_ALTERNATEMASK)
  548.    {  return [super getInspectorClassName];
  549.    }
  550.    
  551.    return "WWButtonCellIBInspector"; 
  552. }
  553.  
  554. @end
  555.